home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cpp_libs / sos3-2.lha / src / agg / Set.c < prev   
C/C++ Source or Header  |  1992-01-23  |  13KB  |  376 lines
  1. /* --------------------------------------------------------------------------
  2.  * Copyright 1992 by Forschungszentrum Informatik (FZI)
  3.  *
  4.  * You can use and distribute this software under the terms of the licence
  5.  * you should have received along with this program.
  6.  * If not or if you want additional information, write to
  7.  * Forschungszentrum Informatik, "STONE", Haid-und-Neu-Strasse 10-14,
  8.  * D-7500 Karlsruhe 1, Germany.
  9.  * --------------------------------------------------------------------------
  10.  */
  11. // **************************************************************************
  12. // Module Set                       03/07/89           Bernhard Schiefer (bs)
  13. //                                                     modified: 23/7/90 (ja)
  14. //                                                              24/10/91 (bs)
  15. // **************************************************************************
  16. // implements methods of classes: Set
  17. // **************************************************************************
  18.  
  19. #include "agg_err.h"
  20. #include "trc_agg.h"
  21. #include "sys.h"
  22.  
  23. #include "agg_sos.h"
  24.  
  25. // *** Sets are based on Object_sos_Bool_Mappings ***
  26.  
  27. // **************************************************************************
  28. void sos_Object_Set::local_initialize (sos_Object_Set set)
  29. // **************************************************************************
  30. {  T_PROC ("sos_Object_Set::local_initialize");
  31.    TT (agg_H, T_ENTER);
  32.  
  33.    set.set_m (sos_Object_sos_Bool_Mapping::create
  34.          (set.container(),
  35.           set.get_list_cursor(),
  36.           set.get_based_on_equal()));
  37.  
  38.    TT (agg_H, T_LEAVE);
  39. } // ** local_initialize **
  40.  
  41. // **************************************************************************
  42. void sos_Object_Set::local_finalize (sos_Object_Set set)
  43. // **************************************************************************
  44. {  T_PROC ("sos_Object_Set::local_finalize");
  45.    TT (agg_H, T_ENTER);
  46.  
  47.    set.get_m().destroy();
  48.  
  49.    TT (agg_H, T_LEAVE);
  50. } // ** local_finalize **
  51.  
  52. // **************************************************************************
  53. void sos_Object_Set::insert (sos_Object o)
  54. // **************************************************************************
  55. // fuege das Objekt o in das Set ein, es wird die Anzahl der danach im
  56. // Set vorhandenen Exemplare geliefert.
  57. {
  58.    T_PROC ("sos_Object_Set::insert");
  59.    TT (agg_H, T_ENTER);
  60.  
  61.    sos_Object_sos_Bool_Mapping m = self.get_m();
  62.    m.insert (o, TRUE);
  63.  
  64.    TT (agg_H, T_LEAVE);
  65. } // ** insert **
  66.  
  67. // **************************************************************************
  68. void sos_Object_Set::remove (sos_Object o)
  69. // **************************************************************************
  70. // loesche ein Objekt o, es wird TRUE,geliefert, falls es drin war
  71. {  
  72.    T_PROC ("sos_Object_Set::remove");
  73.    TT (agg_H, T_ENTER);
  74.  
  75.    self.get_m().remove (o);
  76.  
  77.    TT (agg_H, T_LEAVE);
  78. } // ** remove **
  79.  
  80. // **************************************************************************
  81. void sos_Object_Set::operator+= (sos_Object_Set aset)
  82. // **************************************************************************
  83. // Nach A += B wurden alle Elemente in B zu A aufaddiert
  84. {
  85.    T_PROC ("sos_Object_Set::operator+=");
  86.    TT (agg_H, T_ENTER);
  87.  
  88.    sos_Object_sos_Bool_Mapping this_m = self.get_m();
  89.    sos_Object_sos_Bool_Mapping aset_m = aset.get_m();
  90.  
  91.    sos_Cursor cur = aset_m.open_cursor ();
  92.    for (;aset_m.is_valid (cur); aset_m.to_succ (cur))
  93.    {  sos_Object o = aset_m.get_key (cur);
  94.       this_m.insert (o, TRUE);
  95.    } // for
  96.    aset_m.close_cursor (cur);
  97.  
  98.    TT (agg_H, T_LEAVE);
  99. } // ** operator+= **
  100.  
  101. // **************************************************************************
  102. void sos_Object_Set::operator-= (sos_Object_Set aset)
  103. // **************************************************************************
  104. // Nach A -= B wurden aus A alle Elemente, die in B sind, entfernt
  105. {  
  106.    T_PROC ("sos_Object_Set::operator-=");
  107.    TT (agg_H, T_ENTER);
  108.  
  109.    sos_Object_sos_Bool_Mapping this_m = self.get_m();
  110.    sos_Object_sos_Bool_Mapping aset_m = aset.get_m();
  111.  
  112.    sos_Cursor cur = aset_m.open_cursor();
  113.    for (;aset_m.is_valid (cur);aset_m.to_succ (cur))
  114.    {  sos_Object o = aset_m.get_key (cur);
  115.       this_m.remove (o);
  116.    } // for
  117.    aset_m.close_cursor (cur);
  118.  
  119.    TT (agg_H, T_LEAVE);
  120. } // ** operator-= **
  121.  
  122. // **************************************************************************
  123. void sos_Object_Set::operator*= (sos_Object_Set aset)
  124. // **************************************************************************
  125. // Liefert die Schnittmenge von A und B in A,
  126. // Also entferne aus self alle Elemente, die nicht in aset sind
  127. {
  128.    T_PROC ("sos_Object_Set::operator*=");
  129.    TT (agg_H, T_ENTER);
  130.  
  131.    sos_Object_sos_Bool_Mapping aset_m = aset.get_m();
  132.    sos_Object_sos_Bool_Mapping this_m = self.get_m();
  133.  
  134.    sos_Cursor cur = this_m.open_cursor();
  135.    for (;this_m.is_valid (cur);)
  136.    {  sos_Object o = this_m.get_key (cur);
  137.       if (NOT aset_m.is_key (o))
  138.          this_m.remove_at (cur);
  139.       else
  140.          this_m.to_succ (cur);
  141.    } // for 
  142.    this_m.close_cursor (cur);
  143.  
  144.    TT (agg_H, T_LEAVE);
  145. } // ** operator*= **
  146.  
  147. // **************************************************************************
  148. sos_Bool sos_Object_Set::operator< (sos_Object_Set aset)
  149. // **************************************************************************
  150. // Liefert TRUE zurueck, wenn jedes Element aus this auch in aset ist
  151. // und aset mindestens ein Element mehr enthaelt
  152. { 
  153.    T_PROC ("sos_Object_Set::operator<");
  154.    TT (agg_H, T_ENTER);
  155.  
  156.    sos_Object_sos_Bool_Mapping aset_m = aset.get_m();
  157.    sos_Object_sos_Bool_Mapping this_m = self.get_m();
  158.    sos_Bool result = TRUE;
  159.  
  160.    if (this_m.card() >= aset_m.card())
  161.       result = FALSE;
  162.    else
  163.    {  sos_Cursor cur = this_m.open_cursor();
  164.       for (;this_m.is_valid (cur);this_m.to_succ (cur))
  165.       {  sos_Object o = this_m.get_key (cur);
  166.          if (NOT aset_m.is_key (o))
  167.          {  result = FALSE;
  168.             break;
  169.          }
  170.       } // for
  171.       this_m.close_cursor (cur);
  172.    }
  173.  
  174.    TT (agg_H, T_LEAVE);
  175.    return result;
  176. } // ** operator< **
  177.  
  178. // **************************************************************************
  179. sos_Bool sos_Object_Set::operator<= (sos_Object_Set aset)
  180. // **************************************************************************
  181. // Liefert TRUE zurueck, wenn jedes Element aus this auch in aset ist
  182. { 
  183.    T_PROC ("sos_Object_Set::operator<=");
  184.    TT (agg_H, T_ENTER);
  185.  
  186.    sos_Object_sos_Bool_Mapping aset_m = aset.get_m();
  187.    sos_Object_sos_Bool_Mapping this_m = self.get_m();
  188.    sos_Bool result = TRUE;
  189.  
  190.    // pruefe zuerst, ob die Anzahl der Elemente schon ein Ergebnis liefert
  191.    if (this_m.card() > aset_m.card())
  192.       result = FALSE;
  193.    else
  194.    {  sos_Cursor cur = this_m.open_cursor();
  195.       for (;this_m.is_valid (cur); this_m.to_succ (cur))
  196.       {  sos_Object o = this_m.get_key (cur);
  197.          if (NOT aset_m.is_key (o))
  198.          {  result = FALSE;
  199.             break;
  200.          }
  201.       } // for
  202.       this_m.close_cursor (cur);
  203.    }
  204.    TT (agg_H, T_LEAVE);
  205.    return result;
  206. } // ** operator<= **
  207.  
  208. // **************************************************************************
  209. sos_Bool sos_Object_Set::operator> (sos_Object_Set aset)
  210. { return sos_Bool (aset < self); }
  211. // **************************************************************************
  212.  
  213. // **************************************************************************
  214. sos_Bool sos_Object_Set::operator>= (sos_Object_Set aset)
  215. { return sos_Bool (aset <= self); }
  216. // **************************************************************************
  217.  
  218. // **************************************************************************
  219. void sos_Object_Set::local_assign (sos_Object_Set x, sos_Object o)
  220. // **************************************************************************
  221. {  T_PROC ("sos_Object_Set::local_assign");
  222.    TT(agg_H, T_ENTER);
  223.  
  224.    sos_Object_Set y = sos_Object_Set::make (o);
  225.    x.get_m().assign (y.get_m());
  226.  
  227.    TT(agg_H, T_LEAVE);
  228. } // local_assign
  229.  
  230. // **************************************************************************
  231. sos_Bool sos_Object_Set::local_equal (sos_Object_Set x,
  232.                       sos_Object     o,
  233.                        sos_Eq_kind    eq_kind)
  234. // **************************************************************************
  235. {  T_PROC ("sos_Object_Set::local_equal");
  236.    TT(agg_H, T_ENTER);
  237.    
  238.    sos_Bool result;
  239.  
  240.    if ((eq_kind EQ EQ_STRONG AND NOT o.has_type (x.type())) OR
  241.        (eq_kind EQ EQ_WEAK   AND NOT o.isa      (x.type())))
  242.       result = FALSE;
  243.    else
  244.    {  sos_Object_Set y = sos_Object_Set::make (o);
  245.       result = x.get_m().equal (y.get_m(), eq_kind);
  246.    }
  247.  
  248.    TT(agg_H, T_LEAVE);
  249.    return result;
  250. } // local_equal
  251.  
  252. // **************************************************************************
  253. sos_Int sos_Object_Set::local_hash_value (sos_Object_Set x)
  254. // **************************************************************************
  255. {  T_PROC ("sos_Object_Set::local_hash_value");
  256.    TT(agg_H, T_ENTER);
  257.    
  258.    sos_Int result = x.get_m().hash_value ();
  259.  
  260.    TT(agg_H, T_LEAVE);
  261.  
  262.    return result;
  263. } // local_hash_value
  264.  
  265. // **************************************************************************
  266. sos_Bool sos_Object_Set::is_element (sos_Object o)
  267. // **************************************************************************
  268. {  T_PROC ("sos_Object_Set::is_element");
  269.    TT (agg_H, T_ENTER);
  270.  
  271.    sos_Bool result = self.get_m().is_key (o);
  272.  
  273.    TT (agg_H, T_LEAVE);
  274.    return result;
  275. } // ** is_element(sos_Object)
  276.  
  277. // **************************************************************************
  278. sos_Object sos_Object_Set::get (sos_Cursor c)
  279. // **************************************************************************
  280. {  T_PROC ("sos_Object_Set::get");
  281.    TT (agg_H, T_ENTER);
  282.  
  283.    sos_Object o = self.get_m().get_key (c);
  284.  
  285.    TT (agg_H, T_LEAVE);
  286.    return o;
  287. } // ** get **
  288.  
  289. // **************************************************************************
  290. void sos_Object_Set::remove_at (sos_Cursor c)
  291. // **************************************************************************
  292. {  T_PROC ("sos_Object_Set::remove_at");
  293.    TT (agg_H, T_ENTER);
  294.  
  295.    self.get_m().remove_at (c);
  296.  
  297.    TT (agg_H, T_LEAVE);
  298. } // ** remove_at **
  299.  
  300. // **************************************************************************
  301. void sos_Object_Set::clear()
  302. // **************************************************************************
  303. {  T_PROC ("sos_Object_Set::clear");
  304.    TT (agg_H, T_ENTER);
  305.    
  306.    self.get_m().clear();
  307.  
  308.    TT (agg_H, T_LEAVE);
  309. } // ** clear
  310.  
  311. // **************************************************************************
  312. sos_Int sos_Object_Set::card ()
  313. // **************************************************************************
  314. {  return self.get_m().card ();
  315. } // card
  316.  
  317. // **************************************************************************
  318. sos_Cursor sos_Object_Set::open_cursor (sos_Container Cursor_ct)
  319. // **************************************************************************
  320. {  return self.get_m().open_cursor (Cursor_ct);
  321. } // open_cursor
  322.  
  323. // **************************************************************************
  324. void sos_Object_Set::close_cursor (sos_Cursor c)
  325. // **************************************************************************
  326. {  self.get_m().close_cursor (c);
  327. } // close_cursor
  328.  
  329. // **************************************************************************
  330. sos_Cursor sos_Object_Set::duplicate (sos_Cursor c)
  331. // **************************************************************************
  332. {  return self.get_m().duplicate (c);
  333. } // duplicate
  334.  
  335. // **************************************************************************
  336. sos_Bool sos_Object_Set::is_valid (sos_Cursor c)
  337. // **************************************************************************
  338. {  return self.get_m().is_valid (c);
  339. } // ** is_valid **
  340.  
  341. // **************************************************************************
  342. sos_Bool sos_Object_Set::to_first (sos_Cursor c)
  343. // **************************************************************************
  344. {  return self.get_m().to_first (c);
  345. } // to_first
  346.  
  347. // **************************************************************************
  348. sos_Bool sos_Object_Set::to_last (sos_Cursor c)
  349. // **************************************************************************
  350. {  return self.get_m().to_last (c);
  351. } // to_last
  352.  
  353. // **************************************************************************
  354. sos_Bool sos_Object_Set::to_succ (sos_Cursor c, sos_Int steps)
  355. // **************************************************************************
  356. {  T_PROC ("sos_Object_Set::to_succ");
  357.    TT (agg_H, T_ENTER);
  358.  
  359.    sos_Bool result = self.get_m().to_succ (c, steps);
  360.  
  361.    TT (agg_H, T_LEAVE);
  362.    return result;
  363. } // ** to_succ**
  364.  
  365. // **************************************************************************
  366. sos_Bool sos_Object_Set::to_pred (sos_Cursor c, sos_Int steps)
  367. // **************************************************************************
  368. {  T_PROC ("sos_Object_Set::to_pred");
  369.    TT (agg_H, T_ENTER);
  370.  
  371.    sos_Bool result = self.get_m().to_pred (c, steps);
  372.    
  373.    TT (agg_H, T_LEAVE);
  374.    return result;
  375. } // ** to_pred **
  376.